# -*- coding: utf-8 -*-
"""
批量文本向量化示例
"""

import asyncio
import sys
import os

# 添加项目根目录到系统路径
sys.path.append(os.path.dirname(os.path.dirname(os.path.dirname(os.path.abspath(__file__)))))

from embedding import EmbeddingClient, VectorStore
from embedding.utils import get_vector_statistics


async def batch_text_example():
    """批量文本向量化示例"""
    print("=== 批量文本向量化示例 ===")
    
    # 初始化客户端
    client = EmbeddingClient()
    store = VectorStore()
    
    # 示例文本列表
    texts = [
        "这是一份关于贪污腐败的举报信，涉及金额巨大。",
        "反映某领导干部在工程建设中存在违规操作问题。",
        "举报某单位在人事任命过程中存在徇私舞弊行为。",
        "反映某部门在资金使用方面存在严重问题。",
        "举报某领导在项目审批过程中收受贿赂。",
        "反映某单位在招投标过程中存在暗箱操作。",
        "举报某干部在土地征用过程中存在违法行为。",
        "反映某部门在政策执行过程中存在偏差。",
        "举报某领导在财务管理方面存在严重问题。",
        "反映某单位在环保监管方面存在失职行为。"
    ]
    
    try:
        # 同步批量向量化
        print("\n1. 同步批量向量化:")
        results = client.embed_batch(texts)
        print(f"成功向量化 {len(results)} 个文本")
        
        # 显示前几个结果
        for i, result in enumerate(results[:3]):
            print(f"文本{i+1}: {result.text[:30]}...")
            print(f"向量维度: {len(result.vector)}")
            print(f"向量前3个值: {result.vector[:3]}")
            print()
        
        # 异步批量向量化
        print("\n2. 异步批量向量化:")
        results_async = await client.embed_batch_async(texts)
        print(f"成功异步向量化 {len(results_async)} 个文本")
        
        # 存储向量
        print("\n3. 存储向量:")
        vector_ids = store.add_vectors(
            results, 
            tags=["批量示例"], 
            extra_info={"source": "batch_text_example", "count": len(results)}
        )
        print(f"存储了 {len(vector_ids)} 个向量")
        
        # 向量统计
        print("\n4. 向量统计:")
        vectors = [result.vector for result in results]
        stats = get_vector_statistics(vectors)
        for key, value in stats.items():
            print(f"{key}: {value}")
        
        # 相似度搜索示例
        print("\n5. 相似度搜索示例:")
        if results:
            query_vector = results[0].vector
            similar_results = store.search_similar(query_vector, top_k=5, threshold=0.5)
            print(f"找到 {len(similar_results)} 个相似向量:")
            for vector_id, similarity, metadata in similar_results:
                print(f"相似度: {similarity:.4f}, 文本: {metadata.text[:40]}...")
        
        # 文本搜索示例
        print("\n6. 文本搜索示例:")
        query_text = "贪污腐败"
        text_search_results = store.search_by_text(query_text, top_k=3, threshold=0.3)
        print(f"搜索文本 '{query_text}' 的结果:")
        for vector_id, similarity, metadata in text_search_results:
            print(f"相似度: {similarity:.4f}, 文本: {metadata.text[:50]}...")
        
        # 存储统计
        print("\n7. 存储统计:")
        store_stats = store.get_stats()
        for key, value in store_stats.items():
            print(f"{key}: {value}")
            
    except Exception as e:
        print(f"批量示例执行失败: {e}")


def sync_batch_text_example():
    """同步批量文本向量化示例"""
    print("=== 同步批量文本向量化示例 ===")
    
    # 初始化客户端
    client = EmbeddingClient()
    store = VectorStore()
    
    # 示例文本列表
    texts = [
        "第一个示例文本，用于测试批量处理功能。",
        "第二个示例文本，包含不同的内容信息。",
        "第三个示例文本，用于验证向量化效果。"
    ]
    
    try:
        # 批量向量化
        results = client.embed_batch(texts)
        print(f"成功向量化 {len(results)} 个文本")
        
        # 显示结果
        for i, result in enumerate(results):
            print(f"文本{i+1}: {result.text}")
            print(f"向量维度: {len(result.vector)}")
            print()
        
        # 存储向量
        vector_ids = store.add_vectors(results, tags=["同步批量示例"])
        print(f"存储了 {len(vector_ids)} 个向量")
        
        # 验证存储
        all_vectors = store.get_all_vectors()
        print(f"存储中共有 {len(all_vectors)} 个向量")
        
    except Exception as e:
        print(f"同步批量示例执行失败: {e}")


async def performance_test():
    """性能测试示例"""
    print("=== 性能测试示例 ===")
    
    client = EmbeddingClient()
    
    # 生成测试文本
    test_texts = [f"这是第{i}个测试文本，用于性能测试。" for i in range(1, 21)]
    
    try:
        # 测试同步批量处理
        import time
        start_time = time.time()
        results = client.embed_batch(test_texts)
        sync_time = time.time() - start_time
        
        print(f"同步批量处理 {len(test_texts)} 个文本耗时: {sync_time:.2f}秒")
        print(f"平均每个文本: {sync_time/len(test_texts):.3f}秒")
        
        # 测试异步批量处理
        start_time = time.time()
        results_async = await client.embed_batch_async(test_texts)
        async_time = time.time() - start_time
        
        print(f"异步批量处理 {len(test_texts)} 个文本耗时: {async_time:.2f}秒")
        print(f"平均每个文本: {async_time/len(test_texts):.3f}秒")
        
        # 性能对比
        if sync_time > 0 and async_time > 0:
            improvement = (sync_time - async_time) / sync_time * 100
            print(f"异步处理性能提升: {improvement:.1f}%")
            
    except Exception as e:
        print(f"性能测试失败: {e}")


if __name__ == "__main__":
    # 运行同步批量示例
    sync_batch_text_example()
    
    # 运行异步批量示例
    asyncio.run(batch_text_example())
    
    # 运行性能测试
    asyncio.run(performance_test())
